/**
 * 存储管理模块
 * 负责保存和恢复录音进度
 */
class StorageManager {
    constructor() {
        this.localStorageAvailable = this.isLocalStorageAvailable();
        this.recordingProgressKey = 'voice_recording_progress';
        this.wordSegmentsKey = 'voice_recording_word_segments';
        this.currentWordIndexKey = 'voice_recording_current_word_index';
        this.audioDataKey = 'voice_recording_audio_data';
        this.timestampKey = 'voice_recording_timestamp';
        
        // 最大过期时间（毫秒）- 24小时
        this.maxExpiryTime = 24 * 60 * 60 * 1000; 
    }
    
    /**
     * 检查localStorage是否可用
     * @returns {boolean} localStorage是否可用
     */
    isLocalStorageAvailable() {
        try {
            const testKey = '__storage_test__';
            localStorage.setItem(testKey, testKey);
            localStorage.removeItem(testKey);
            return true;
        } catch (e) {
            return false;
        }
    }
    
    /**
     * 保存录音进度
     * @param {Object} data 录音进度数据
     * @returns {boolean} 是否保存成功
     */
    saveProgress(data) {
        if (!this.localStorageAvailable) return false;
        
        try {
            // 添加时间戳
            const timestamp = Date.now();
            localStorage.setItem(this.timestampKey, timestamp.toString());
            
            // 保存数据
            localStorage.setItem(this.recordingProgressKey, JSON.stringify(data));
            return true;
        } catch (e) {
            console.error('保存录音进度失败:', e);
            return false;
        }
    }
    
    /**
     * 获取录音进度
     * @returns {Object|null} 录音进度数据或null
     */
    getProgress() {
        if (!this.localStorageAvailable) {
            console.log('localStorage不可用，无法获取录音进度');
            return null;
        }
        
        try {
            // 检查时间戳
            const timestamp = parseInt(localStorage.getItem(this.timestampKey));
            if (isNaN(timestamp)) {
                console.log('未找到有效的录音时间戳');
                return null;
            }
            
            // 检查是否过期
            const now = Date.now();
            if (now - timestamp > this.maxExpiryTime) {
                // 过期了，清除数据
                console.log('录音数据已过期，自动清除');
                this.clearProgress();
                return null;
            }
            
            // 获取数据
            const dataStr = localStorage.getItem(this.recordingProgressKey);
            if (!dataStr) {
                console.log('未找到录音进度数据');
                return null;
            }
            
            const data = JSON.parse(dataStr);
            console.log('成功获取录音进度数据:', data);
            return data;
        } catch (e) {
            console.error('获取录音进度失败:', e);
            return null;
        }
    }
    
    /**
     * 保存单词分段数据
     * @param {Array} wordSegments 单词分段数据
     * @returns {boolean} 是否保存成功
     */
    saveWordSegments(wordSegments) {
        if (!this.localStorageAvailable) return false;
        
        try {
            localStorage.setItem(this.wordSegmentsKey, JSON.stringify(wordSegments));
            return true;
        } catch (e) {
            console.error('保存单词分段数据失败:', e);
            return false;
        }
    }
    
    /**
     * 获取单词分段数据
     * @returns {Array|null} 单词分段数据或null
     */
    getWordSegments() {
        if (!this.localStorageAvailable) {
            console.log('localStorage不可用，无法获取单词分段数据');
            return null;
        }
        
        try {
            const dataStr = localStorage.getItem(this.wordSegmentsKey);
            if (!dataStr) {
                console.log('未找到单词分段数据');
                return null;
            }
            
            const data = JSON.parse(dataStr);
            console.log('成功获取单词分段数据，数量:', data.length);
            return data;
        } catch (e) {
            console.error('获取单词分段数据失败:', e);
            return null;
        }
    }
    
    /**
     * 保存当前单词索引
     * @param {number} index 当前单词索引
     * @returns {boolean} 是否保存成功
     */
    saveCurrentWordIndex(index) {
        if (!this.localStorageAvailable) return false;
        
        try {
            localStorage.setItem(this.currentWordIndexKey, index.toString());
            return true;
        } catch (e) {
            console.error('保存当前单词索引失败:', e);
            return false;
        }
    }
    
    /**
     * 获取当前单词索引
     * @returns {number|null} 当前单词索引或null
     */
    getCurrentWordIndex() {
        if (!this.localStorageAvailable) return null;
        
        try {
            const indexStr = localStorage.getItem(this.currentWordIndexKey);
            if (!indexStr) return null;
            
            const index = parseInt(indexStr);
            return isNaN(index) ? null : index;
        } catch (e) {
            console.error('获取当前单词索引失败:', e);
            return null;
        }
    }
    
    /**
     * 保存音频数据（使用 Base64 编码）
     * @param {Blob} audioBlob 音频Blob对象
     * @returns {Promise<boolean>} 是否保存成功
     */
    async saveAudioData(audioBlob) {
        if (!this.localStorageAvailable) return false;
        
        try {
            // 检查Blob是否有效
            if (!audioBlob || !(audioBlob instanceof Blob)) {
                console.error('无效的音频数据');
                return false;
            }
            
            // 将Blob转换为Base64
            const base64 = await this.blobToBase64(audioBlob);
            
            // 保存数据
            localStorage.setItem(this.audioDataKey, base64);
            return true;
        } catch (e) {
            console.error('保存音频数据失败:', e);
            return false;
        }
    }
    
    /**
     * 获取音频数据
     * @returns {Promise<Blob|null>} 音频Blob对象或null
     */
    async getAudioData() {
        if (!this.localStorageAvailable) return null;
        
        try {
            const base64 = localStorage.getItem(this.audioDataKey);
            if (!base64) return null;
            
            // 将Base64转换为Blob
            return this.base64ToBlob(base64, 'audio/wav');
        } catch (e) {
            console.error('获取音频数据失败:', e);
            return null;
        }
    }
    
    /**
     * 将Blob对象转换为Base64字符串
     * @param {Blob} blob Blob对象
     * @returns {Promise<string>} Base64字符串
     */
    blobToBase64(blob) {
        return new Promise((resolve, reject) => {
            const reader = new FileReader();
            reader.onloadend = () => {
                const base64 = reader.result;
                resolve(base64);
            };
            reader.onerror = reject;
            reader.readAsDataURL(blob);
        });
    }
    
    /**
     * 将Base64字符串转换为Blob对象
     * @param {string} base64 Base64字符串
     * @param {string} mimeType MIME类型
     * @returns {Blob} Blob对象
     */
    base64ToBlob(base64, mimeType) {
        const byteString = atob(base64.split(',')[1]);
        const ab = new ArrayBuffer(byteString.length);
        const ia = new Uint8Array(ab);
        
        for (let i = 0; i < byteString.length; i++) {
            ia[i] = byteString.charCodeAt(i);
        }
        
        return new Blob([ab], { type: mimeType });
    }
    
    /**
     * 清除所有录音进度数据
     */
    clearProgress() {
        if (!this.localStorageAvailable) return;
        
        try {
            localStorage.removeItem(this.recordingProgressKey);
            localStorage.removeItem(this.wordSegmentsKey);
            localStorage.removeItem(this.currentWordIndexKey);
            localStorage.removeItem(this.audioDataKey);
            localStorage.removeItem(this.timestampKey);
        } catch (e) {
            console.error('清除录音进度数据失败:', e);
        }
    }
}

// 创建单例实例并导出
window.storageManager = new StorageManager(); 